home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 22 / Cream of the Crop 22.iso / program / jdp1_4.zip / JDP1_4.EXE / data.1 / JDPLayout3.java < prev    next >
Text File  |  1996-11-06  |  19KB  |  646 lines
  1. >XXX0619  Total lines for the build status message calculation
  2. //--------------------------------------------------------------------
  3. //                                                                    
  4. >001//  Module:       <JDPModule>                                       
  5. >002//  Description:  <Class Description>
  6. //                                                                    
  7. //--------------------------------------------------------------------
  8.  
  9. import java.awt.*;
  10. import java.applet.*;
  11. import java.util.StringTokenizer;
  12. import java.util.Vector;
  13.  
  14.  
  15. >003public class <JDPUserBill> extends JDPClassLayout {
  16.  
  17.     JDPUser user;
  18.     JDPJagg jaggSQL;
  19.     JDPWhereClause jdpWhereClause;
  20.     JDPSearchResults searchResults;
  21.     JDPTextGrid tableContents;
  22.     JDPPopupMessage popuppanel;
  23.     JDPTabSelectPanel tabPanel;
  24.  
  25.     String[] psortChoice;
  26.     String[] pdisplayChoice;
  27.     int itemIndex;
  28.     boolean insertRequested = false;
  29.     boolean deleteRequested = false;
  30.     String pfromWhereClause;
  31.     String[][] rowKey;
  32.     int totalRows;
  33.     int keyCount;
  34.     int prevColumnCount;
  35. >119    int columnCount = <columnCount>;
  36.  
  37.     Vector pmatchUsing;
  38.     Vector pactualmatchUsing;
  39.     //
  40.     //  Declare screen components
  41.     //
  42. >004    <TextField username>;
  43. >052    Vector value<name>;
  44.  
  45.  
  46.     public void InitClass(JDPUser user, Panel targetPanel, String moduleParameter) {
  47.  
  48.         this.user = user;
  49.         //
  50.         //  Set JAGG settings for this class
  51.         //
  52.         jaggSQL = new JDPJagg(user.jaggPath);
  53.         jaggSQL.setNULL("space");
  54. >997        jaggSQL.setMRW("<maxRows>");
  55. >998        jaggSQL.setDSN("<datasource>");
  56. >999        jaggSQL.setCSTR("<connectstr>");
  57.  
  58.         setLayout(new BorderLayout());
  59.         setFont(user.plainFont);
  60.          popuppanel = new JDPPopupMessage(user,targetPanel);
  61.         targetPanel.add(popuppanel);
  62.  
  63.         Panel mainPanel = new Panel();
  64.         mainPanel.setLayout(new BorderLayout());
  65.         Panel centerPanel = new Panel();
  66.         centerPanel.setLayout(new BorderLayout());
  67.         Panel centerMainPanel = new Panel();
  68.         centerMainPanel.setLayout(new GridLayout(2,1,1,1));
  69.         Panel centerBottomPanel = new Panel();
  70.         centerBottomPanel.setLayout(new BorderLayout());
  71.         Panel leftPanel = new Panel();
  72.         leftPanel.setLayout(new BorderLayout());
  73.         
  74.         //
  75.         //  Define parameters for JDPSearchResults
  76.         //
  77. >005        String pselectFields = "<>"; String[] psdisplayFields = {<>};
  78. >006        pfromWhereClause = "<FROM JDPUser WHERE >";
  79.  
  80. >007        psortChoice = new String[<5>];
  81. >008        psortChoice[<0>] = "<username>";
  82.  
  83. >009        String[] psortChoiceText = {<"Sort by User Name","Sort by Card Number">};
  84.         pdisplayChoice = psortChoice;
  85.  
  86. >010        boolean pdisplayCount = <true>;
  87. >011        String pcountText = "<Total Entries:>";
  88.     
  89.         //
  90.         //  Create an instance of screen components
  91.         //
  92. >012        <username> = new <TextField("",20)>;
  93.  
  94.         //
  95.         //  Add components to the screen
  96.         //
  97. >058        JDPScrollPanel[] centerTopPanel = new JDPScrollPanel[<>];
  98. >059        centerTopPanel[<>] = new JDPScrollPanel();
  99. >013        centerTopPanel[<>].add("Left",new JDPWrapLabel(user,"<User Name:>",Color.<labelColor>));
  100. >014        centerTopPanel[<>].add("Right",centerR<0>);
  101.  
  102.         if (centerTopPanel.length == 1) {
  103.             centerMainPanel.add(centerTopPanel[0]);
  104.         } else {
  105. >060            String[] titles = {<>};
  106.             tabPanel = new JDPTabSelectPanel(user,titles,centerTopPanel,"North");
  107.             centerMainPanel.add(tabPanel);
  108.         }
  109.         
  110.         // 
  111.         //  Set screen component attributes
  112.         //
  113. >039        <username>.setForeground(Color.<fcolor>);
  114. >040        <username>.setBackground(Color.<bcolor>);
  115. >048        popuppanel.addComponent(<>,"<>","<>");
  116.         
  117.         //
  118.         //  Create a new instance of a Grid
  119.         //
  120.         tableContents = new JDPTextGrid(user);
  121.         centerBottomPanel.add("Center",tableContents);
  122.         centerMainPanel.add(centerBottomPanel);
  123.         //
  124.         //  Add buttons to the bottom of the panel
  125.         //
  126.         if (moduleParameter.compareTo("Inquiry") == 0) {
  127. >041            <username>.setEditable(false);
  128.         } else {
  129. >042            <username>.setEditable(<editable>);
  130. >015            String buttons[] = {<"   Apply   ","Reset","New","Copy","Remove">};
  131. >047            int icons[] = {<>};
  132.             JDPButtons btns = new JDPButtons(user, buttons, icons, JDPButtons.HORIZONTAL);
  133.             centerBottomPanel.add("South",btns);
  134. >046            popuppanel.addComponent(btns.button[<0>],"<>","<>");
  135.         }
  136.         mainPanel.add("Center",centerMainPanel);
  137.         
  138.         //
  139.         //  Define parameters for JDPWhereClause
  140.         //
  141. >016        String[] pchooseFrom = new String[<7>];
  142. >017        pchooseFrom[<0>] = "<Account Name>";
  143.  
  144. >018        String[] pactualchooseFrom = new String[<7>];
  145. >019        pactualchooseFrom[<0>] = "<username>";
  146.  
  147.         loadMatchUsing();
  148.  
  149. >024        boolean[] constantIsString = new boolean[<7>];
  150. >025        constantIsString[<0>] = <true>;
  151.  
  152. >026        int[] constantLength = new int[<7>];
  153. >027        constantLength[<0>] = <20>;
  154.  
  155.         //
  156.         //  Initialise any choice components
  157.         //
  158.         loadChoices();
  159.  
  160.         //
  161.         //  Add JDPWhereClause search panel
  162.         //
  163.         if (pchooseFrom.length > 0) {
  164. >028            jdpWhereClause = new JDPWhereClause(user, targetPanel, "<UserBill>", true, "<pinitChoice>", pchooseFrom, pactualchooseFrom,
  165.                                                 pmatchUsing, pactualmatchUsing, null, null,
  166.                                                 constantLength, constantIsString);
  167.             leftPanel.add("North",jdpWhereClause);
  168.         }
  169.         //
  170.         //  Add JDPSearchResults result list
  171.         //
  172.         if (psortChoice.length > 0) {
  173. >029            searchResults = new JDPSearchResults(user, targetPanel, <true>, jaggSQL, <false>, pselectFields, psdisplayFields, pfromWhereClause, psortChoiceText, psortChoice, pdisplayChoice, "<pinitChoice>", pdisplayCount, pcountText);
  174. >055            int icons[] = {<>};
  175. >056            searchResults.setMinWidth(<>);
  176.             searchResults.setIcons(icons);
  177.             leftPanel.add("Center",searchResults);
  178.             mainPanel.add("West",leftPanel);
  179.         }
  180.  
  181. >030        add("Center",new JDPChiselFramePanel(user,"<User Billing Details>",mainPanel,"North"));
  182.         if (psortChoice.length > 0) {
  183.             newSearch();
  184.         }
  185.         //
  186.         //  Add the handle to this panel to the global vector so other panels can
  187.         //  access this one
  188.         //
  189.         user.gParm.addElement(this);
  190.     }
  191.  
  192.     //
  193.     //  Handle screen events
  194.     //
  195.     public boolean handleEvent(Event e) {
  196.  
  197.         switch (e.id) {
  198.         case Event.ACTION_EVENT:
  199.             if (e.target instanceof List) {
  200.                 if (e.target.equals(searchResults.resultList)) {
  201.                     loadData();
  202.                     return true;
  203.                 }
  204.             }
  205.             if (e.target instanceof JDPTreePicker) {
  206.                 if (e.target.equals(searchResults.tree)) {
  207.                     loadData();
  208.                     return true;
  209.                 }
  210.             }
  211.             if (e.target instanceof Button) {
  212.                 String choice = (String)e.arg;
  213.                 if (choice.trim().compareTo("New") == 0) {
  214.                     clearFields(false);
  215.                     loadEmptyGrid();
  216.                     return true;
  217.                 }
  218.                 if (choice.trim().compareTo("Apply") == 0) {
  219.                     if (checkFields()) {
  220.                         checkRows();
  221.                     }
  222.                     return true;
  223.                 }
  224.                 if (choice.trim().compareTo("Reset") == 0) {
  225.                     loadGrid();
  226.                     return true;
  227.                 }
  228.                 if (choice.trim().compareTo("Remove") == 0) {
  229. >054                    String removeMsg = "<>";
  230.                     if (removeMsg.equals("") || user.mainmsg.getStatusMsg().equals(removeMsg)) {
  231.                         deleteRequested = true;
  232.                         checkRows();
  233.                     } else {
  234.                         user.mainmsg.setStatusMsg(removeMsg,15);
  235.                     }
  236.                     return true;
  237.                 }
  238.                 if (choice.trim().compareTo("Search") == 0) {
  239.                     newSearch();
  240.                     return true;
  241.                 }
  242.                 return true;
  243.             }
  244.             if (e.target instanceof Choice) {
  245.                 return true;
  246.             }
  247.             if (e.target instanceof TextField) {
  248.                 if ((jdpWhereClause != null) && (e.target.equals(jdpWhereClause.matchConstant))) {
  249.                     insertRequested = false;
  250.                     deleteRequested = false;
  251.                     newSearch();
  252.                     return true;
  253.                 }
  254.                 checkFields();
  255.                 return true;
  256.             }
  257.             return false;
  258.  
  259.         case Event.KEY_PRESS:
  260.             if (e.key == '\t') {
  261.                 //  handle tabbing between components
  262.                 if (e.modifiers != Event.SHIFT_MASK) {
  263. >031                    if (e.target.equals(<username>)) { user.u.cursor(<username>); return true; }
  264.                 } else {
  265. >038                    if (e.target.equals(<username>)) { user.u.cursor(<username>); return true; }
  266.                 }
  267.                 return true;
  268.             }
  269.             return false;
  270.  
  271.         case Event.WINDOW_EXPOSE:
  272.             if (e.target instanceof JDPTabSelectPanel) {
  273.                 if (e.target.equals(user.jdpMenuPanel)) {
  274.                     //
  275.                     //  This is where you place code to get executed when this panel is
  276.                     //  reactivated from the tab menu
  277.                     //
  278.                     return true;
  279.                 }
  280.             }
  281.             return false;
  282.  
  283.           case Event.MOUSE_MOVE:
  284.          case Event.MOUSE_ENTER:
  285.          case Event.MOUSE_EXIT:
  286.             popuppanel.postEvent(e);
  287.             return false;
  288.  
  289.         default:
  290.             return false;
  291.  
  292.         }
  293.     }
  294.  
  295.     //
  296.     //  Retrieve the handle to another panel so as to be able to interact with it
  297.     //
  298.     public void retrieveHandle() {
  299.  
  300.         for (int ix=0; ix<user.gParm.size(); ix++) {
  301.             //
  302.             //  Activate the next four lines of code to retrieve the handle to another 
  303.             //  Panel within your JDP system. Of course you should declare the variable 
  304.             //  at the top of this source instead of within this method so you can 
  305.             //  access it from all the methods within this class. You only need to 
  306.             //  substitute DemoClass with the name ouf your class. You should call this 
  307.             //  method from somewhere else in this class. To access a variable from 
  308.             //  your resulting class use:
  309.             //     if (DemoClassHandle != null) mynewvar = demoClassHandle.variable;
  310.             //
  311. //            if (user.gParm.elementAt(ix) instanceof DemoClass19) {
  312. //                DemoClass19 DemoClassHandle = (DemoClass19)user.gParm.elementAt(ix);
  313. //                return;
  314. //            }
  315.         }
  316.     }
  317.  
  318.     //
  319.     //  The search button was pressed so rerun the query with the new search criteria
  320.     //
  321.     public void newSearch() {
  322.  
  323.         String whereClause;
  324.  
  325.         whereClause = pfromWhereClause;
  326.         if (jdpWhereClause != null) {
  327.             whereClause = whereClause + " AND " + jdpWhereClause.whereClause;
  328.         }
  329.         searchResults.setFromWhereClause(whereClause);
  330. >057        searchResults.clearList(<>);
  331.         searchResults.loadList();
  332.     }
  333.  
  334.     //
  335.     //  Load the selected item
  336.     //
  337.     public void loadData() {
  338.  
  339.         StringTokenizer stok;
  340.  
  341.         int recCount = 0;
  342.         Vector results = new Vector();
  343.         String sep = jaggSQL.getSEP();
  344.         int actualRows = 0;
  345.         String row;
  346.         String tempText;
  347.  
  348.         if ((itemIndex = searchResults.getSelectedIndex()) < 0) {
  349.             clearFields(true);
  350.             return;
  351.         }
  352.  
  353. >032        String SQL = <SELECT>;
  354.  
  355.         user.mainmsg.setStatusMsg("Accessing database...", 0);
  356.         recCount = jaggSQL.execSQL(SQL, results);
  357.  
  358.         if(recCount == -1) {
  359.             user.u.setSqlMessage(jaggSQL,SQL);
  360.             return;
  361.         }
  362.         if(recCount >= 1) {
  363.             row = (String)results.elementAt(0);
  364.             if ((row != null) && (row.trim().compareTo("") != 0)) {
  365.                 stok = new StringTokenizer(row);
  366.  
  367. >033                <username>.setText(stok.nextToken(sep).trim());
  368.             }
  369.             loadGrid();
  370. //            if(recCount > 1) {
  371. //                user.mainmsg.setStatusMsg("Multiple records found - first match only displayed.", 10);
  372. //            } else {
  373.                 user.mainmsg.clearStatusMsg();
  374. //            }
  375.         } else {
  376.             user.mainmsg.setStatusMsg("Requested entry does not exist.", 10);
  377.             clearFields(true);
  378.         }
  379.  
  380.     }
  381.  
  382.     //
  383.     //  Load the grid with the specified parameters and selected data
  384.     //
  385.     public void loadGrid() {
  386.  
  387.         StringTokenizer stok;
  388.         int recCount = 0;
  389.         Vector results = new Vector();
  390.         String sep = jaggSQL.getSEP();
  391.         int actualRows = 0;
  392.         String row;
  393.         String tempText;
  394.  
  395.         Vector columns = new Vector();
  396.         Vector indexes = new Vector();
  397.  
  398. >100        String SQL = <SELECT>;
  399.  
  400.         user.mainmsg.setStatusMsg("Accessing database...", 0);
  401.  
  402.         recCount = jaggSQL.execSQL(SQL, results);
  403.  
  404.         if(recCount == -1) {
  405.             user.u.setSqlMessage(jaggSQL,SQL);
  406.             return;
  407.         }
  408.  
  409.         //
  410.         //  Initialise result arrays
  411.         //
  412.         actualRows = jaggSQL.getRowCount()+20;
  413.         totalRows = jaggSQL.getRowCount();
  414.         tableContents.currentText = new String[columnCount][actualRows];
  415.         //
  416.         //  If we haven't already initialise the grid settings
  417.         //
  418.         if (columnCount != prevColumnCount) {
  419.             prevColumnCount = columnCount;
  420.             setGridSettings();
  421.         }
  422.         tableContents.cellChanged = null;
  423.         tableContents.rowChanged = null;
  424.         tableContents.columnSelected = null;
  425. >120        keyCount = <keycount>;
  426.         rowKey = new String[actualRows][keyCount];
  427.         
  428.         //
  429.         //  Load key array and grid array
  430.         //
  431.         for (int ix=0; ix<actualRows-20; ix++) {
  432.             row = (String)results.elementAt(ix);
  433.             if ((row != null) && (row.trim().compareTo("") != 0)) {
  434.                 stok = new StringTokenizer(row);
  435.                 for (int iy=0; iy<keyCount; iy++) {
  436.                     rowKey[ix][iy] = stok.nextToken(sep).trim();
  437.                 }
  438.                 for (int iy=0; iy<columnCount; iy++) {
  439.                     tempText = stok.nextToken(sep).trim();
  440.                     tableContents.currentText[iy][ix] = tempText;
  441. >053                    if ((iy == <1>) && (value<field>.indexOf(tempText) >= 0)) tableContents.currentText[iy][ix] = tableContents.pullDownList[<1>][0].getItem(value<field>.indexOf(tempText));
  442.                 }
  443.             }
  444.         }
  445.  
  446.         tableContents.newTable();
  447.  
  448.         //
  449.         //  Clear status message
  450.         //
  451.         user.mainmsg.clearStatusMsg();
  452.     }
  453.  
  454.     //
  455.     //  Load the grid with the blank rows to allow data entry
  456.     //
  457.     public void loadEmptyGrid() {
  458.  
  459.         tableContents.currentText = new String[columnCount][50];
  460.         tableContents.cellChanged = null;
  461.         tableContents.rowChanged = null;
  462.         tableContents.columnSelected = null;
  463.         rowKey = new String[50][keyCount];
  464.         tableContents.newTable();
  465.         totalRows = 0;
  466.     }
  467.  
  468.     //
  469.     //  Set up the parameters for this grid
  470.     //
  471.     public void setGridSettings() {
  472.  
  473.         tableContents.columnHeader = new String[columnCount];
  474.         tableContents.columnHeaderStyle = new int[columnCount];
  475.         tableContents.columnStyle = new int[columnCount];
  476.         tableContents.columnHeaderColor = new Color[columnCount];
  477.         tableContents.columnColor = new Color[columnCount];
  478.         tableContents.columnBGColor = new Color[columnCount];
  479.         tableContents.columnProtected = new boolean[columnCount];
  480.         tableContents.columnWidth = new int[columnCount];
  481.         tableContents.rightJustify = new boolean[columnCount];
  482.         tableContents.rowHeader = null;
  483.         tableContents.columnHeight = null;
  484.         for (int ix=0; ix<columnCount; ix++) {
  485.             tableContents.columnHeaderStyle[ix] = Font.BOLD;
  486.             tableContents.columnStyle[ix] = Font.PLAIN;
  487.             tableContents.columnHeaderColor[ix] = Color.black;
  488.             tableContents.columnColor[ix] = Color.black;
  489.             tableContents.columnBGColor[ix] = Color.white;
  490.             tableContents.columnStyle[ix] = Font.PLAIN;
  491.         }
  492. >101        tableContents.columnHeader[<ix>] = "<>";
  493. >102        tableContents.columnHeaderStyle[<ix>] = <>;
  494. >103        tableContents.columnStyle[<ix>] = <>;
  495. >104        tableContents.columnHeaderColor[<ix>] = user.u._cvtcolor("<>");
  496. >105        tableContents.columnColor[<ix>] = user.u._cvtcolor("<>");
  497. >106        tableContents.columnBGColor[<ix>] = user.u._cvtcolor("<>");
  498. >107        tableContents.columnProtected[<ix>] = <>;
  499. >108        tableContents.columnWidth[<ix>] = <>;
  500. >109        tableContents.rightJustify[<ix>] = <>;
  501.  
  502.     }
  503.  
  504.     //
  505.     //  The check each rows that has changed and issue an update to the database
  506.     //
  507.     public void checkRows() {
  508.  
  509.         int changedCount = 0;
  510.         int insertedCount = 0;
  511.         int deletedCount = 0;
  512.         int cCount = 1;
  513.         int iCount = 1;
  514.         
  515.         for (int ix=0; ix<tableContents.rowChanged.length; ix++) {
  516.             if (deleteRequested && tableContents.rowSelected[ix]) {
  517.                 deletedCount++;
  518.             } else
  519.             if (tableContents.rowChanged[ix]) {
  520.                 if (ix >= totalRows) {
  521.                     insertedCount++;
  522.                 } else {
  523.                     changedCount++;
  524.                 }
  525.             }
  526.         }
  527.         for (int ix=0; ix<tableContents.rowChanged.length; ix++) {
  528.             if (deleteRequested && tableContents.rowSelected[ix]) {
  529.                 user.mainmsg.setStatusMsg("Deleting row " + Integer.toString(iCount++) + " of " + Integer.toString(deletedCount) + "...", 0);
  530.                 saveData(ix);
  531.             } else
  532.             if (tableContents.rowChanged[ix]) {
  533.                 insertRequested = false;
  534.                 if (ix >= totalRows) {
  535.                     insertRequested = true;
  536.                     user.mainmsg.setStatusMsg("Inserting row " + Integer.toString(iCount++) + " of " + Integer.toString(insertedCount) + "...", 0);
  537.                 } else {
  538.                     user.mainmsg.setStatusMsg("Updating row " + Integer.toString(cCount++) + " of " + Integer.toString(changedCount) + "...", 0);
  539.                 }
  540.                 saveData(ix);
  541.                 insertRequested = false;
  542.                 tableContents.rowChanged[ix] = false;
  543.             }
  544.         }
  545.         if ((deletedCount > 0) || (insertedCount > 0)) {
  546.             loadGrid();
  547.         }
  548.         deleteRequested = false;
  549.     }
  550.  
  551.     //
  552.     //  Save the selected item
  553.     //
  554.     public boolean saveData(int tableRow) {
  555.  
  556.         int recCount = 0;
  557.         Vector results = new Vector();
  558.         String sep = jaggSQL.getSEP();
  559.         String SQL = "";
  560.  
  561.         if (insertRequested) {
  562. >121            SQL = <INSERT INTO >;
  563.         } else {
  564.             if (deleteRequested) {
  565. >122                SQL = <DELETE FROM >;
  566.             } else {
  567. >123                SQL = <UPDATE >;
  568.             }
  569.         }
  570.  
  571.         recCount = jaggSQL.execSQL(SQL, results);
  572.  
  573.         if (user.DEBUG) System.out.println("saveData CNT: "+Integer.toString(recCount));
  574.  
  575.         if(recCount == -1) {
  576.             user.u.setSqlMessage(jaggSQL,SQL);
  577.             return false;
  578.         }
  579.         if(recCount == 1) {
  580.             if (insertRequested) {
  581.                 user.mainmsg.setStatusMsg("Record successfully added.",3);
  582.             } else 
  583.             if (deleteRequested) {
  584.                 user.mainmsg.setStatusMsg("Record successfully removed.",3);
  585.             } else {
  586.                 user.mainmsg.setStatusMsg("Record successfully updated.",3);
  587.             }
  588.         } else {
  589.             user.u.setSqlMessage(jaggSQL,SQL);
  590.         }
  591.         return true;
  592.  
  593.     }
  594.  
  595.     //
  596.     //  Clear the screen fields for a new option
  597.     //
  598.     public void clearFields(boolean clearKey) {
  599.  
  600. >037        <username>.setText("<>");
  601.         loadEmptyGrid();
  602.  
  603.     }
  604.  
  605.     //
  606.     //  Load the Search Layout pulldown choices
  607.     //
  608.     public void loadMatchUsing() {
  609.  
  610.         pmatchUsing = new Vector();
  611.         pactualmatchUsing = new Vector();
  612. >020        pmatchUsing.addElement(new Vector());
  613. >022        pactualmatchUsing.addElement(new Vector());
  614. >021        ((Vector)pmatchUsing.elementAt(<0>)).addElement("<Begins with>");
  615. >023        ((Vector)pactualmatchUsing.elementAt(<0>)).addElement("< like >");
  616.  
  617.     }
  618.  
  619.     //
  620.     //  Load all of the Screen Choices
  621.     //
  622.     public void loadChoices() {
  623. >043
  624. >044        new JDPLoadChoice(user,jaggSQL,<choicename>,"<choicecolumnname>","<actualcolumnname>","<tablename>","<whereclause>",value<columnname>);
  625.  
  626.         tableContents.isPullDownCol = new boolean[columnCount];
  627.         tableContents.pullDownList = new List[columnCount][1];
  628. >049        tableContents.isPullDownCol[<1>] = true;
  629. >049        tableContents.pullDownList[<1>][0] = new List();
  630. >050
  631. >051        new JDPLoadChoice(user,jaggSQL,tableContents.pullDownList[<1>][0],"<choicecolumnname>","<actualcolumnname>","<tablename>","<whereclause>",value<columnname>);
  632.     }
  633.  
  634.     //
  635.     //  Perform component validations
  636.     //
  637.     public boolean checkFields() {
  638.  
  639. >045        if (!user.u.<isnumeric>(<field>,user.mainmsg,"<>")) return false;
  640.         return true;
  641.  
  642.     }
  643.  
  644.  
  645. }
  646.